﻿#define _CRT_SECURE_NO_WARNINGS 1
//在柠檬水摊上，每一杯柠檬水的售价为 5 美元。
//
//顾客排队购买你的产品，（按账单 bills 支付的顺序）一次购买一杯。
//
//每位顾客只买一杯柠檬水，然后向你付 5 美元、10 美元或 20 美元。你必须给每个顾客正确找零，也就是说净交易是每位顾客向你支付 5 美元。
//
//注意，一开始你手头没有任何零钱。
//
//如果你能给每位顾客正确找零，返回 true ，否则返回 false 。
//
//来源：力扣（LeetCode）
//链接：https ://leetcode-cn.com/problems/lemonade-change
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//bool lemonadeChange(int* bills, int billsSize){
//	int five = 0;
//	int ten = 0;
//	int two = 0;
//	for (int i = 0; i<billsSize; i++)
//	{
//		if (bills[i] == 5)
//		{
//			five++;
//		}
//		else if (bills[i] == 10)
//		{
//			if (five == 0)
//			{
//				return 0;
//			}
//			ten++;
//			five--;
//		}
//		else
//		{
//			if (five >= 1 && ten >= 1)
//			{
//				five--;
//				ten--;
//			}
//			else if (five >= 3)
//			{
//				five -= 3;
//			}
//			else
//			{
//				return 0;
//			}
//		}
//	}
//	return 1;
//}







//给定一个字符串 S，返回 “反转后的” 字符串，其中不是字母的字符都保留在原地，而所有字母的位置发生反转。
//char * reverseOnlyLetters(char * s){
//	int len = strlen(s);
//	int j = len - 1, i = 0;
//	while (i<j)
//	{
//		while (i<len&&!(s[i] >= 'a'&&s[i] <= 'z' || s[i] >= 'A'&&s[i] <= 'Z'))
//		{
//			i++;
//		}
//		while (j >= 0 && !(s[j] >= 'a'&&s[j] <= 'z' || s[j] >= 'A'&&s[j] <= 'Z'))
//		{
//			j--;
//		}
//		if (i<j)
//		{
//			char tmp = s[i];
//			s[i] = s[j];
//			s[j] = tmp;
//			i++;
//			j--;
//		}
//	}
//	return s;
//}
//






//给定两个字符串, A 和 B。
//
//A 的旋转操作就是将 A 最左边的字符移动到最右边。 例如, 若 A = 'abcde'，在移动一次之后结果就是'bcdea' 。如果在若干次旋转操作之后，A 能变成B，那么返回True。
//来源：力扣（LeetCode）
//链接：https ://leetcode-cn.com/problems/rotate-string
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//bool rotateString(char * s, char * goal){
//	int lens = strlen(s);
//	int leng = strlen(goal);
//	if (lens != leng)
//	{
//		return 0;
//	}
//	char*a = (char*)calloc(sizeof(char), (lens * 2 + 1));
//	strcat(strcat(a, s), s);
//	return strstr(a, goal);
//}







//我们称一个数 X 为好数, 如果它的每位数字逐个地被旋转 180 度后，我们仍可以得到一个有效的，且和 X 不同的数。要求每位数字都要被旋转。
//
//如果一个数的每位数字被旋转以后仍然还是一个数字， 则这个数是有效的。0, 1, 和 8 被旋转后仍然是它们自己；2 和 5 可以互相旋转成对方（在这种情况下，它们以不同的方向旋转，换句话说，2 和 5 互为镜像）；6 和 9 同理，除了这些以外其他的数字旋转以后都不再是有效的数字。
//
//现在我们有一个正整数 N, 计算从 1 到 N 中有多少个数 X 是好数？
//
//来源：力扣（LeetCode）
//链接：https ://leetcode-cn.com/problems/rotated-digits
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//int rotatedDigits(int n){
//	int j = 0;
//	int sum = 0;
//	for (int i = 0; i <= n; i++)
//	{
//		int a = i;
//		while (a)
//		{
//			int x = a % 10;
//			if (x == 3 || x == 4 || x == 7)
//			{
//				break;
//			}
//			if (x == 2 || x == 5 || x == 6 || x == 9)
//			{
//				j++;
//			}
//			a /= 10;
//		}
//		if (j>0 && a <= 0)
//		{
//			sum++;
//		}
//		j = 0;
//	}
//	return sum;
//}







//给定由一些正数（代表长度）组成的数组 A，返回由其中三个长度组成的、面积不为零的三角形的最大周长。
//
//如果不能形成任何面积不为零的三角形，返回 0。
//int cmp(void* a, void* b)
//{
//	int A = *(int*)a, B = *(int*)b;
//	return A - B;
//}
//int largestPerimeter(int* nums, int numsSize){
//	qsort(nums, numsSize, sizeof(int), cmp);
//	for (int i = numsSize - 1; i >= 2; i--)
//	{
//		if (nums[i - 2] + nums[i - 1]>nums[i])
//		{
//			return nums[i - 2] + nums[i - 1] + nums[i];
//		}
//	}
//	return 0;
//}







/**对于非负整数 X 而言，X 的数组形式是每位数字按从左到右的顺序形成的数组。例如，如果 X = 1231，那么其数组形式为 [1,2,3,1]。

给定非负整数 X 的数组形式 A，返回整数 X+K 的数组形式。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/add-to-array-form-of-integer
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
* Note: The returned array must be malloced, assume caller calls free().
*/
//int* addToArrayForm(int* num, int numSize, int k, int* returnSize){
//	int*a = (int*)malloc(sizeof(int)*fmax(10, numSize + 1));
//	*returnSize = 0;
//	for (int i = numSize - 1; i >= 0; i--)
//	{
//		int sum = num[i] + k % 10;
//		k /= 10;
//		if (sum >= 10)
//		{
//			k++;
//			sum -= 10;
//		}
//		a[(*returnSize)++] = sum;
//	}
//	for (; k>0; k /= 10)
//	{
//		a[(*returnSize)++] = k % 10;
//	}
//	for (int i = 0; i<(*returnSize) / 2; i++)
//	{
//		int tmp = a[i];
//		a[i] = a[(*returnSize) - 1 - i];
//		a[(*returnSize) - 1 - i] = tmp;
//	}
//	return a;
//}






//
//每个非负整数 N 都有其二进制表示。例如， 5 可以被表示为二进制 "101"，11 可以用二进制 "1011" 表示，依此类推。注意，除 N = 0 外，任何二进制表示中都不含前导零。
//二进制的反码表示是将每个 1 改为 0 且每个 0 变为 1。例如，二进制数 "101" 的二进制反码为 "010"。
//给你一个十进制数 N，请你返回其二进制表示的反码所对应的十进制整数。
//来源：力扣（LeetCode）
//链接：https ://leetcode-cn.com/problems/complement-of-base-10-integer
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//int bitwiseComplement(int n){
//	int max = 0;
//	int count = 0;
//	int tmp = n;
//	while (tmp)
//	{
//		tmp /= 2;
//		count++;
//	}
//	max = pow(2, count) - 1;
//	return n == 0 ? 1 : max - n;
//}







/**给定仅有小写字母组成的字符串数组 A，返回列表中的每个字符串中都显示的全部字符（包括重复字符）组成的列表。例如，如果一个字符在每个字符串中出现 3 次，但不是 4 次，则需要在最终答案中包含该字符 3 次。

你可以按任意顺序返回答案。

 

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/find-common-characters
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
* Note: The returned array must be malloced, assume caller calls free().
*/
//char ** commonChars(char ** words, int wordsSize, int* returnSize){
//	int min[26], freq[26];
//	int i = 0;
//	int j = 0;
//	for (i = 0; i<26; i++)
//	{
//		min[i] = INT_MAX;
//		freq[i] = 0;
//	}
//	for (i = 0; i<wordsSize; i++)
//	{
//		memset(freq, 0, sizeof(freq));
//		int len = strlen(words[i]);
//		for (j = 0; j<len; j++)
//		{
//			++freq[words[i][j] - 'a'];
//		}
//		for (j = 0; j<26; j++)
//		{
//			min[j] = fmin(min[j], freq[j]);
//		}
//	}
//	int sum = 0;
//	for (i = 0; i<26; i++)
//	{
//		sum += min[i];
//	}
//	char**a = malloc(sizeof(char*)*sum);
//	*returnSize = 0;
//	for (i = 0; i<26; i++)
//	{
//		for (j = 0; j<min[i]; j++)
//		{
//			a[*returnSize] = malloc(sizeof(char) * 2);
//			a[*returnSize][0] = i + 'a';
//			a[*returnSize][1] = 0;
//			(*returnSize)++;
//		}
//	}
//	return a;
//}








/**「无零整数」是十进制表示中 不含任何 0 的正整数。

给你一个整数 n，请你返回一个 由两个整数组成的列表 [A, B]，满足：

A 和 B 都是无零整数
A + B = n
题目数据保证至少有一个有效的解决方案。

如果存在多个有效解决方案，你可以返回其中任意一个。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/convert-integer-to-the-sum-of-two-no-zero-integers
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
* Note: The returned array must be malloced, assume caller calls free().
*/
//int Nothavezero(int num)
//{
//	if (num == 0)
//	{
//		return 0;
//	}
//	while (num)
//	{
//		int tmp = num % 10;
//		num /= 10;
//		if (tmp == 0)
//		{
//			return 0;
//		}
//	}
//	return 1;
//}
//int* getNoZeroIntegers(int n, int* returnSize){
//	int*a = (int*)malloc(sizeof(int) * 2);
//	*returnSize = 2;
//	for (int i = 1; i<n; i++)
//	{
//		if (Nothavezero(i) && Nothavezero(n - i))
//		{
//			a[0] = i;
//			a[1] = n - i;
//			return a;
//		}
//	}
//	a[0] = -1;
//	a[1] = -1;
//	return a;
//}








//请你来实现一个 myAtoi(string s) 函数，使其能将字符串转换成一个 32 位有符号整数（类似 C / C++ 中的 atoi 函数）。
//函数 myAtoi(string s) 的算法如下：
//读入字符串并丢弃无用的前导空格
//检查下一个字符（假设还未到字符末尾）为正还是负号，读取该字符（如果有）。 确定最终结果是负数还是正数。 如果两者都不存在，则假定结果为正。
//读入下一个字符，直到到达下一个非数字字符或到达输入的结尾。字符串的其余部分将被忽略。
//将前面步骤读入的这些数字转换为整数（即，"123" -> 123， "0032" -> 32）。如果没有读入数字，则整数为 0 。必要时更改符号（从步骤 2 开始）。
//如果整数数超过 32 位有符号整数范围[−231, 231 − 1] ，需要截断这个整数，使其保持在这个范围内。具体来说，小于 −231 的整数应该被固定为 −231 ，大于 231 − 1 的整数应该被固定为 231 − 1 。
//返回整数作为最终结果。
//注意：
//本题中的空白字符只包括空格字符 ' ' 。
//除前导空格或数字后的其余字符串外，请勿忽略 任何其他字符。
//来源：力扣（LeetCode）
//链接：https ://leetcode-cn.com/problems/string-to-integer-atoi
//著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//int myAtoi(char * s){
//	long num = 0;
//	int i = 0;
//	int count = 1;
//	while (s[i] == ' ')
//	{
//		i++;
//	}
//	if (s[i] == '-' || s[i] == '+')
//	{
//		count = 44 - s[i++];
//	}
//	while (s[i] >= '0'&&s[i] <= '9')
//	{
//		num = num * 10 + s[i++] - '0';
//		if (num != (int)num)
//		{
//			break;
//		}
//	}
//	num *= count;
//	return num == (int)num ? (int)num : num<0 ? -2147483648 : 2147483647;
//}
